LCOV - code coverage report
Current view: top level - src/ev - fiber_exec.c (source / functions) Hit Total Coverage
Test: Lely core libraries-2.4.0 Code Coverage Lines: 311 436 71.3 %
Date: 2024-05-21 10:56:08 Functions: 34 40 85.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 66 152 43.4 %

           Branch data     Line data    Source code
       1                 :            : /**@file
       2                 :            :  * This file is part of the event library; it contains the implementation of the
       3                 :            :  * fiber executor functions.
       4                 :            :  *
       5                 :            :  * @see lely/ev/fiber_exec.h
       6                 :            :  *
       7                 :            :  * @copyright 2019-2021 Lely Industries N.V.
       8                 :            :  *
       9                 :            :  * @author J. S. Seldenthuis <jseldenthuis@lely.com>
      10                 :            :  *
      11                 :            :  * Licensed under the Apache License, Version 2.0 (the "License");
      12                 :            :  * you may not use this file except in compliance with the License.
      13                 :            :  * You may obtain a copy of the License at
      14                 :            :  *
      15                 :            :  *     http://www.apache.org/licenses/LICENSE-2.0
      16                 :            :  *
      17                 :            :  * Unless required by applicable law or agreed to in writing, software
      18                 :            :  * distributed under the License is distributed on an "AS IS" BASIS,
      19                 :            :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      20                 :            :  * See the License for the specific language governing permissions and
      21                 :            :  * limitations under the License.
      22                 :            :  */
      23                 :            : 
      24                 :            : #include "ev.h"
      25                 :            : 
      26                 :            : #if !LELY_NO_MALLOC
      27                 :            : 
      28                 :            : #if !LELY_NO_THREADS
      29                 :            : #include <lely/libc/threads.h>
      30                 :            : #endif
      31                 :            : #include <lely/ev/exec.h>
      32                 :            : #include <lely/ev/fiber_exec.h>
      33                 :            : #include <lely/ev/task.h>
      34                 :            : #include <lely/util/errnum.h>
      35                 :            : #include <lely/util/util.h>
      36                 :            : 
      37                 :            : #include <assert.h>
      38                 :            : #include <stdint.h>
      39                 :            : #include <stdlib.h>
      40                 :            : 
      41                 :            : #ifndef LELY_EV_FIBER_MAX_UNUSED
      42                 :            : /// The maximum number of unused fibers per thread.
      43                 :            : #define LELY_EV_FIBER_MAX_UNUSED 16
      44                 :            : #endif
      45                 :            : 
      46                 :            : struct ev_fiber_ctx;
      47                 :            : 
      48                 :            : /**
      49                 :            :  * The parameters used for creating fibers on this thread and the list of unused
      50                 :            :  * fibers.
      51                 :            :  */
      52                 :            : #if LELY_NO_THREADS
      53                 :            : static struct ev_fiber_thrd {
      54                 :            : #else
      55                 :            : static _Thread_local struct ev_fiber_thrd {
      56                 :            : #endif
      57                 :            :         /**
      58                 :            :          * The number of invocations of ev_fiber_thrd_init() minus the the
      59                 :            :          * number of invocation of ev_fiber_thrd_fini() for this thread.
      60                 :            :          */
      61                 :            :         size_t refcnt;
      62                 :            :         /// The flags used when creating each fiber.
      63                 :            :         int flags;
      64                 :            :         /// The size (in bytes) of the stack frame allocated for each fiber.
      65                 :            :         size_t stack_size;
      66                 :            :         /// The maximum number of unused fibers for this thread.
      67                 :            :         size_t max_unused;
      68                 :            :         /// The list of unused fibers.
      69                 :            :         struct ev_fiber_ctx *unused;
      70                 :            :         /// The number of unused fibers.
      71                 :            :         size_t num_unused;
      72                 :            :         /// A pointer to the currently running fiber.
      73                 :            :         struct ev_fiber_ctx *curr;
      74                 :            :         /// A pointer to the previously running (suspended) fiber.
      75                 :            :         fiber_t *prev;
      76                 :            : } ev_fiber_thrd;
      77                 :            : 
      78                 :            : static void ev_fiber_exec_on_task_init(ev_exec_t *exec);
      79                 :            : static void ev_fiber_exec_on_task_fini(ev_exec_t *exec);
      80                 :            : static int ev_fiber_exec_dispatch(ev_exec_t *exec, struct ev_task *task);
      81                 :            : static void ev_fiber_exec_post(ev_exec_t *exec, struct ev_task *task);
      82                 :            : static void ev_fiber_exec_defer(ev_exec_t *exec, struct ev_task *task);
      83                 :            : static size_t ev_fiber_exec_abort(ev_exec_t *exec, struct ev_task *task);
      84                 :            : 
      85                 :            : // clang-format off
      86                 :            : static const struct ev_exec_vtbl ev_fiber_exec_vtbl = {
      87                 :            :         &ev_fiber_exec_on_task_init,
      88                 :            :         &ev_fiber_exec_on_task_fini,
      89                 :            :         &ev_fiber_exec_dispatch,
      90                 :            :         &ev_fiber_exec_post,
      91                 :            :         &ev_fiber_exec_defer,
      92                 :            :         &ev_fiber_exec_abort,
      93                 :            :         NULL
      94                 :            : };
      95                 :            : // clang-format on
      96                 :            : 
      97                 :            : /// The implementation of a fiber executor.
      98                 :            : struct ev_fiber_exec {
      99                 :            :         /// A pointer to the virtual table for the executor interface.
     100                 :            :         const struct ev_exec_vtbl *exec_vptr;
     101                 :            :         /// A pointer to the inner executor.
     102                 :            :         ev_exec_t *inner_exec;
     103                 :            :         /// The task used to create new fibers.
     104                 :            :         struct ev_task task;
     105                 :            :         /// A pointer to the #ev_fiber_thrd instance for this executor.
     106                 :            :         struct ev_fiber_thrd *thr;
     107                 :            :         /// The number of pending fibers available to execute a task.
     108                 :            :         size_t pending;
     109                 :            : #if !LELY_NO_THREADS
     110                 :            :         /// The mutex protecting #posted and #queue.
     111                 :            :         mtx_t mtx;
     112                 :            : #endif
     113                 :            :         /// A flag indicating whether #task has been posted to #inner_exec.
     114                 :            :         int posted;
     115                 :            :         /// The queue of tasks submitted to this executor.
     116                 :            :         struct sllist queue;
     117                 :            : };
     118                 :            : 
     119                 :            : static void ev_fiber_exec_func(struct ev_task *task);
     120                 :            : 
     121                 :            : static inline struct ev_fiber_exec *ev_fiber_exec_from_exec(
     122                 :            :                 const ev_exec_t *exec);
     123                 :            : 
     124                 :            : static int ev_fiber_exec_post_ctx(struct ev_fiber_exec *exec);
     125                 :            : 
     126                 :            : /**
     127                 :            :  * The context of a fiber used for executing tasks. The context is allocated on
     128                 :            :  * the stack of the fiber.
     129                 :            :  */
     130                 :            : struct ev_fiber_ctx {
     131                 :            :         /// A pointer to the fiber containing this context.
     132                 :            :         fiber_t *fiber;
     133                 :            :         /// A pointer to the next fiber in the list of unused fibers.
     134                 :            :         struct ev_fiber_ctx *next;
     135                 :            :         /// The executor using this fiber.
     136                 :            :         struct ev_fiber_exec *exec;
     137                 :            :         /// The task used to resume the fiber.
     138                 :            :         struct ev_task task;
     139                 :            :         /// The queue of deferred tasks.
     140                 :            :         struct sllist queue;
     141                 :            : };
     142                 :            : 
     143                 :            : static struct ev_fiber_ctx *ev_fiber_ctx_create(struct ev_fiber_exec *exec);
     144                 :            : static void ev_fiber_ctx_destroy(struct ev_fiber_ctx *ctx);
     145                 :            : 
     146                 :            : static fiber_t *ev_fiber_ctx_fiber_func(fiber_t *fiber, void *arg);
     147                 :            : static void ev_fiber_ctx_task_func(struct ev_task *task);
     148                 :            : 
     149                 :            : static struct ev_fiber_ctx *ev_fiber_resume(fiber_t *fiber);
     150                 :            : static fiber_t *ev_fiber_await_func(fiber_t *fiber, void *arg);
     151                 :            : 
     152                 :            : static void ev_fiber_return(void);
     153                 :            : static fiber_t *ev_fiber_return_func(fiber_t *fiber, void *arg);
     154                 :            : 
     155                 :            : /// The implementation of a fiber mutex.
     156                 :            : struct ev_fiber_mtx_impl {
     157                 :            :         /// The type of mutex: #ev_fiber_mtx_plain or #ev_fiber_mtx_recursive.
     158                 :            :         int type;
     159                 :            : #if !LELY_NO_THREADS
     160                 :            :         /// The mutex protecting #locked and #queue.
     161                 :            :         mtx_t mtx;
     162                 :            : #endif
     163                 :            :         /// A pointer to the fiber holding the lock.
     164                 :            :         struct ev_fiber_ctx *ctx;
     165                 :            :         /// The number of times the mutex has been recursively locked.
     166                 :            :         size_t locked;
     167                 :            :         /// The queue of fibers waiting to acquire the lock.
     168                 :            :         struct sllist queue;
     169                 :            : };
     170                 :            : 
     171                 :            : static fiber_t *ev_fiber_mtx_lock_func(fiber_t *fiber, void *arg);
     172                 :            : 
     173                 :            : /**
     174                 :            :  * The context of a wait operation on a fiber condition variable. This struct is
     175                 :            :  * allocated on the stack of a fiber in ev_fiber_cnd_wait().
     176                 :            :  */
     177                 :            : struct ev_fiber_cnd_wait {
     178                 :            :         /// The node in the queue of fibers waiting on #cond.
     179                 :            :         struct slnode node;
     180                 :            :         /// A pointer to the condition variable passed to ev_fiber_cnd_wait().
     181                 :            :         ev_fiber_cnd_t *cond;
     182                 :            :         /// A pointer to the mutex passed to ev_fiber_cnd_wait().
     183                 :            :         ev_fiber_mtx_t *mtx;
     184                 :            :         /// A pointer to the task (in #ev_fiber_ctx) used to wake up the fiber.
     185                 :            :         struct ev_task *task;
     186                 :            : };
     187                 :            : 
     188                 :            : static fiber_t *ev_fiber_cnd_wait_func(fiber_t *fiber, void *arg);
     189                 :            : 
     190                 :            : /// The implementation of a fiber condition variable.
     191                 :            : struct ev_fiber_cnd_impl {
     192                 :            : #if !LELY_NO_THREADS
     193                 :            :         /// The mutex protecting #queue.
     194                 :            :         mtx_t mtx;
     195                 :            : #endif
     196                 :            :         /**
     197                 :            :          * The queue of fibers waiting for the condition variable to be
     198                 :            :          * signaled.
     199                 :            :          */
     200                 :            :         struct sllist queue;
     201                 :            : };
     202                 :            : 
     203                 :            : static void ev_fiber_cnd_wake(struct slnode *node);
     204                 :            : 
     205                 :            : int
     206                 :          3 : ev_fiber_thrd_init(int flags, size_t stack_size, size_t max_unused)
     207                 :            : {
     208                 :          3 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     209                 :            : 
     210         [ -  + ]:          3 :         if (thr->refcnt++)
     211                 :          0 :                 return 1;
     212                 :            : 
     213                 :          3 :         int result = fiber_thrd_init(flags & ~FIBER_GUARD_STACK);
     214         [ -  + ]:          3 :         if (result == -1) {
     215                 :          0 :                 thr->refcnt--;
     216                 :            :         } else {
     217                 :          3 :                 thr->flags = flags;
     218                 :          3 :                 thr->stack_size = stack_size;
     219                 :            : 
     220         [ +  - ]:          3 :                 if (!(thr->max_unused = max_unused))
     221                 :          3 :                         thr->max_unused = LELY_EV_FIBER_MAX_UNUSED;
     222                 :          3 :                 thr->unused = NULL;
     223                 :          3 :                 thr->num_unused = 0;
     224                 :            : 
     225                 :          3 :                 thr->curr = NULL;
     226                 :          3 :                 thr->prev = NULL;
     227                 :            :         }
     228                 :          3 :         return result;
     229                 :            : }
     230                 :            : 
     231                 :            : void
     232                 :          3 : ev_fiber_thrd_fini(void)
     233                 :            : {
     234                 :          3 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     235                 :            :         assert(!thr->curr);
     236                 :            : 
     237         [ -  + ]:          3 :         if (--thr->refcnt)
     238                 :          0 :                 return;
     239                 :            : 
     240                 :            :         struct ev_fiber_ctx *ctx;
     241         [ +  + ]:          9 :         while ((ctx = thr->unused)) {
     242                 :          6 :                 thr->unused = ctx->next;
     243                 :          6 :                 fiber_destroy(ctx->fiber);
     244                 :            :         }
     245                 :            : 
     246                 :          3 :         fiber_thrd_fini();
     247                 :            : }
     248                 :            : 
     249                 :            : void *
     250                 :          3 : ev_fiber_exec_alloc(void)
     251                 :            : {
     252                 :          3 :         struct ev_fiber_exec *exec = malloc(sizeof(*exec));
     253         [ -  + ]:          3 :         if (!exec) {
     254                 :            : #if !LELY_NO_ERRNO
     255                 :          0 :                 set_errc(errno2c(errno));
     256                 :            : #endif
     257                 :          0 :                 return NULL;
     258                 :            :         }
     259                 :            :         // Suppress a GCC maybe-uninitialized warning.
     260                 :          3 :         exec->exec_vptr = NULL;
     261                 :            :         // cppcheck-suppress memleak symbolName=exec
     262                 :          3 :         return &exec->exec_vptr;
     263                 :            : }
     264                 :            : 
     265                 :            : void
     266                 :          3 : ev_fiber_exec_free(void *ptr)
     267                 :            : {
     268         [ +  - ]:          3 :         if (ptr)
     269                 :          3 :                 free(ev_fiber_exec_from_exec(ptr));
     270                 :          3 : }
     271                 :            : 
     272                 :            : ev_exec_t *
     273                 :          3 : ev_fiber_exec_init(ev_exec_t *exec_, ev_exec_t *inner_exec)
     274                 :            : {
     275                 :          3 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     276                 :            :         assert(thr->refcnt);
     277                 :          3 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     278                 :            :         assert(inner_exec);
     279                 :            : 
     280                 :          3 :         exec->exec_vptr = &ev_fiber_exec_vtbl;
     281                 :            : 
     282                 :          3 :         exec->inner_exec = inner_exec;
     283                 :          3 :         exec->task = (struct ev_task)EV_TASK_INIT(
     284                 :            :                         exec->inner_exec, &ev_fiber_exec_func);
     285                 :            : 
     286                 :          3 :         exec->thr = thr;
     287                 :            : 
     288                 :          3 :         exec->pending = 0;
     289                 :            : 
     290                 :            : #if !LELY_NO_THREADS
     291         [ -  + ]:          3 :         if (mtx_init(&exec->mtx, mtx_plain) != thrd_success)
     292                 :          0 :                 return NULL;
     293                 :            : #endif
     294                 :            : 
     295                 :          3 :         exec->posted = 0;
     296                 :            : 
     297                 :          3 :         sllist_init(&exec->queue);
     298                 :            : 
     299                 :          3 :         return exec_;
     300                 :            : }
     301                 :            : 
     302                 :            : void
     303                 :          3 : ev_fiber_exec_fini(ev_exec_t *exec_)
     304                 :            : {
     305                 :          3 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     306                 :            :         assert(exec->thr == &ev_fiber_thrd);
     307                 :            : 
     308                 :          3 :         ev_fiber_exec_abort(exec_, NULL);
     309                 :            : 
     310                 :            : #if !LELY_NO_THREADS
     311                 :          3 :         mtx_lock(&exec->mtx);
     312                 :            : #endif
     313                 :            :         // Abort ev_fiber_exec_func().
     314   [ -  +  -  - ]:          3 :         if (exec->posted && ev_exec_abort(exec->task.exec, &exec->task))
     315                 :          0 :                 exec->posted = 0;
     316                 :            :         assert(exec->posted == 0);
     317                 :            : #if !LELY_NO_THREADS
     318                 :          3 :         mtx_unlock(&exec->mtx);
     319                 :            : 
     320                 :          3 :         mtx_destroy(&exec->mtx);
     321                 :            : #endif
     322                 :          3 : }
     323                 :            : 
     324                 :            : ev_exec_t *
     325                 :          3 : ev_fiber_exec_create(ev_exec_t *inner_exec)
     326                 :            : {
     327                 :          3 :         int errc = 0;
     328                 :            : 
     329                 :          3 :         ev_exec_t *exec = ev_fiber_exec_alloc();
     330         [ -  + ]:          3 :         if (!exec) {
     331                 :          0 :                 errc = get_errc();
     332                 :          0 :                 goto error_alloc;
     333                 :            :         }
     334                 :            : 
     335                 :          3 :         ev_exec_t *tmp = ev_fiber_exec_init(exec, inner_exec);
     336         [ -  + ]:          3 :         if (!tmp) {
     337                 :          0 :                 errc = get_errc();
     338                 :          0 :                 goto error_init;
     339                 :            :         }
     340                 :          3 :         exec = tmp;
     341                 :            : 
     342                 :          3 :         return exec;
     343                 :            : 
     344                 :          0 : error_init:
     345                 :          0 :         ev_fiber_exec_free((void *)exec);
     346                 :          0 : error_alloc:
     347                 :          0 :         set_errc(errc);
     348                 :          0 :         return NULL;
     349                 :            : }
     350                 :            : 
     351                 :            : void
     352                 :          3 : ev_fiber_exec_destroy(ev_exec_t *exec)
     353                 :            : {
     354         [ +  - ]:          3 :         if (exec) {
     355                 :          3 :                 ev_fiber_exec_fini(exec);
     356                 :          3 :                 ev_fiber_exec_free((void *)exec);
     357                 :            :         }
     358                 :          3 : }
     359                 :            : 
     360                 :            : ev_exec_t *
     361                 :          0 : ev_fiber_exec_get_inner_exec(const ev_exec_t *exec_)
     362                 :            : {
     363                 :          0 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     364                 :            : 
     365                 :          0 :         return exec->inner_exec;
     366                 :            : }
     367                 :            : 
     368                 :            : void
     369                 :   16777310 : ev_fiber_await(ev_future_t *future)
     370                 :            : {
     371                 :   16777310 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     372                 :            :         assert(thr->curr);
     373                 :            : 
     374                 :   16777310 :         thr->prev = fiber_resume_with(thr->prev, ev_fiber_await_func, future);
     375                 :   16777310 : }
     376                 :            : 
     377                 :            : int
     378                 :          1 : ev_fiber_mtx_init(ev_fiber_mtx_t *mtx, int type)
     379                 :            : {
     380                 :            :         assert(mtx);
     381                 :            : 
     382         [ -  + ]:          1 :         if (type & ~ev_fiber_mtx_recursive) {
     383                 :          0 :                 set_errnum(ERRNUM_INVAL);
     384                 :          0 :                 return ev_fiber_error;
     385                 :            :         }
     386                 :            : 
     387                 :          1 :         struct ev_fiber_mtx_impl *impl = malloc(sizeof(*impl));
     388         [ -  + ]:          1 :         if (!impl)
     389                 :          0 :                 return ev_fiber_nomem;
     390                 :            : 
     391                 :          1 :         impl->type = type;
     392                 :            : 
     393                 :            : #if !LELY_NO_THREADS
     394      [ -  -  + ]:          1 :         switch (mtx_init(&impl->mtx, mtx_plain)) {
     395                 :          0 :         case thrd_error: free(impl); return ev_fiber_error;
     396                 :          0 :         case thrd_nomem: free(impl); return ev_fiber_nomem;
     397                 :          1 :         default: break;
     398                 :            :         }
     399                 :            : #endif
     400                 :            : 
     401                 :          1 :         impl->ctx = NULL;
     402                 :          1 :         impl->locked = 0;
     403                 :          1 :         sllist_init(&impl->queue);
     404                 :            : 
     405                 :          1 :         mtx->_impl = impl;
     406                 :            : 
     407                 :          1 :         return ev_fiber_success;
     408                 :            : }
     409                 :            : 
     410                 :            : void
     411                 :          1 : ev_fiber_mtx_destroy(ev_fiber_mtx_t *mtx)
     412                 :            : {
     413                 :            :         assert(mtx);
     414                 :          1 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
     415                 :            :         assert(impl);
     416                 :            : 
     417                 :            :         assert(!impl->locked);
     418                 :            :         assert(sllist_empty(&impl->queue));
     419                 :            : #if !LELY_NO_THREADS
     420                 :          1 :         mtx_destroy(&impl->mtx);
     421                 :            : #endif
     422                 :          1 :         free(impl);
     423                 :            : 
     424                 :          1 :         mtx->_impl = NULL;
     425                 :          1 : }
     426                 :            : 
     427                 :            : int
     428                 :          4 : ev_fiber_mtx_lock(ev_fiber_mtx_t *mtx)
     429                 :            : {
     430                 :          4 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     431                 :            :         assert(mtx);
     432                 :          4 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
     433                 :            :         assert(impl);
     434                 :            : 
     435         [ -  + ]:          4 :         if (!thr->curr) {
     436                 :          0 :                 set_errnum(ERRNUM_PERM);
     437                 :          0 :                 return ev_fiber_error;
     438                 :            :         }
     439                 :            : 
     440                 :            : #if !LELY_NO_THREADS
     441                 :          4 :         mtx_lock(&impl->mtx);
     442                 :            : #endif
     443         [ +  + ]:          4 :         if (impl->locked) {
     444         [ -  + ]:          1 :                 if (impl->ctx == thr->curr) {
     445         [ #  # ]:          0 :                         if (!(impl->type & ev_fiber_mtx_recursive)) {
     446                 :            : #if !LELY_NO_THREADS
     447                 :          0 :                                 mtx_unlock(&impl->mtx);
     448                 :            : #endif
     449                 :          0 :                                 set_errnum(ERRNUM_PERM);
     450                 :          0 :                                 return ev_fiber_error;
     451                 :            :                         }
     452                 :            :                         assert(impl->locked < SIZE_MAX);
     453                 :          0 :                         impl->locked++;
     454                 :            :                 } else {
     455                 :            :                         // The inner mutex will be unlocked in
     456                 :            :                         // ev_fiber_mtx_lock_func().
     457                 :          1 :                         thr->prev = fiber_resume_with(thr->prev,
     458                 :            :                                         ev_fiber_mtx_lock_func, impl);
     459                 :          1 :                         impl->ctx = thr->curr;
     460                 :            :                         assert(impl->locked == 1);
     461                 :            :                 }
     462                 :            :         } else {
     463                 :            :                 assert(impl->ctx == NULL);
     464                 :            :                 assert(sllist_empty(&impl->queue));
     465                 :          3 :                 impl->ctx = thr->curr;
     466                 :          3 :                 impl->locked = 1;
     467                 :            : #if !LELY_NO_THREADS
     468                 :          3 :                 mtx_unlock(&impl->mtx);
     469                 :            : #endif
     470                 :            :         }
     471                 :            : 
     472                 :          4 :         return ev_fiber_success;
     473                 :            : }
     474                 :            : 
     475                 :            : int
     476                 :          0 : ev_fiber_mtx_trylock(ev_fiber_mtx_t *mtx)
     477                 :            : {
     478                 :          0 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     479                 :            :         assert(mtx);
     480                 :          0 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
     481                 :            :         assert(impl);
     482                 :            : 
     483         [ #  # ]:          0 :         if (!thr->curr) {
     484                 :          0 :                 set_errnum(ERRNUM_PERM);
     485                 :          0 :                 return ev_fiber_error;
     486                 :            :         }
     487                 :            : 
     488                 :            : #if !LELY_NO_THREADS
     489                 :          0 :         mtx_lock(&impl->mtx);
     490                 :            : #endif
     491         [ #  # ]:          0 :         if (impl->locked) {
     492         [ #  # ]:          0 :                 if (impl->ctx == thr->curr) {
     493         [ #  # ]:          0 :                         if (!(impl->type & ev_fiber_mtx_recursive)) {
     494                 :            : #if !LELY_NO_THREADS
     495                 :          0 :                                 mtx_unlock(&impl->mtx);
     496                 :            : #endif
     497                 :          0 :                                 set_errnum(ERRNUM_PERM);
     498                 :          0 :                                 return ev_fiber_error;
     499                 :            :                         }
     500                 :            :                         assert(impl->locked < SIZE_MAX);
     501                 :          0 :                         impl->locked++;
     502                 :            : #if !LELY_NO_THREADS
     503                 :          0 :                         mtx_unlock(&impl->mtx);
     504                 :            : #endif
     505                 :          0 :                         return ev_fiber_success;
     506                 :            :                 } else {
     507                 :            : #if !LELY_NO_THREADS
     508                 :          0 :                         mtx_unlock(&impl->mtx);
     509                 :            : #endif
     510                 :          0 :                         return ev_fiber_busy;
     511                 :            :                 }
     512                 :            :         } else {
     513                 :            :                 assert(impl->ctx == NULL);
     514                 :            :                 assert(sllist_empty(&impl->queue));
     515                 :          0 :                 impl->ctx = thr->curr;
     516                 :          0 :                 impl->locked = 1;
     517                 :            : #if !LELY_NO_THREADS
     518                 :          0 :                 mtx_unlock(&impl->mtx);
     519                 :            : #endif
     520                 :          0 :                 return ev_fiber_success;
     521                 :            :         }
     522                 :            : }
     523                 :            : 
     524                 :            : int
     525                 :          4 : ev_fiber_mtx_unlock(ev_fiber_mtx_t *mtx)
     526                 :            : {
     527                 :          4 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     528                 :            :         assert(mtx);
     529                 :          4 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
     530                 :            :         assert(impl);
     531                 :            : 
     532         [ -  + ]:          4 :         if (!thr->curr) {
     533                 :          0 :                 set_errnum(ERRNUM_PERM);
     534                 :          0 :                 return ev_fiber_error;
     535                 :            :         }
     536                 :            : 
     537                 :          4 :         struct ev_task *task = NULL;
     538                 :            : 
     539                 :            : #if !LELY_NO_THREADS
     540                 :          4 :         mtx_lock(&impl->mtx);
     541                 :            : #endif
     542   [ +  -  -  + ]:          4 :         if (impl->ctx != thr->curr || !impl->locked) {
     543                 :            : #if !LELY_NO_THREADS
     544                 :          0 :                 mtx_unlock(&impl->mtx);
     545                 :            : #endif
     546                 :          0 :                 set_errnum(ERRNUM_PERM);
     547                 :          0 :                 return ev_fiber_error;
     548                 :            :         }
     549                 :            :         assert((impl->type & ev_fiber_mtx_recursive) || impl->locked == 1);
     550         [ +  - ]:          4 :         if (!--impl->locked) {
     551                 :          4 :                 impl->ctx = NULL;
     552         [ +  + ]:          4 :                 if ((task = ev_task_from_node(sllist_pop_front(&impl->queue))))
     553                 :          2 :                         impl->locked++;
     554                 :            :         }
     555                 :            : #if !LELY_NO_THREADS
     556                 :          4 :         mtx_unlock(&impl->mtx);
     557                 :            : #endif
     558                 :            : 
     559         [ +  + ]:          4 :         if (task)
     560                 :          2 :                 ev_exec_post(task->exec, task);
     561                 :            : 
     562                 :          4 :         return ev_fiber_success;
     563                 :            : }
     564                 :            : 
     565                 :            : int
     566                 :          1 : ev_fiber_cnd_init(ev_fiber_cnd_t *cond)
     567                 :            : {
     568                 :            :         assert(cond);
     569                 :            : 
     570                 :          1 :         struct ev_fiber_cnd_impl *impl = malloc(sizeof(*impl));
     571         [ -  + ]:          1 :         if (!impl)
     572                 :          0 :                 return ev_fiber_nomem;
     573                 :            : 
     574                 :            : #if !LELY_NO_THREADS
     575      [ -  -  + ]:          1 :         switch (mtx_init(&impl->mtx, mtx_plain)) {
     576                 :          0 :         case thrd_error: free(impl); return ev_fiber_error;
     577                 :          0 :         case thrd_nomem: free(impl); return ev_fiber_nomem;
     578                 :          1 :         default: break;
     579                 :            :         }
     580                 :            : #endif
     581                 :            : 
     582                 :          1 :         sllist_init(&impl->queue);
     583                 :            : 
     584                 :          1 :         cond->_impl = impl;
     585                 :            : 
     586                 :          1 :         return ev_fiber_success;
     587                 :            : }
     588                 :            : 
     589                 :            : void
     590                 :          1 : ev_fiber_cnd_destroy(ev_fiber_cnd_t *cond)
     591                 :            : {
     592                 :            :         assert(cond);
     593                 :          1 :         struct ev_fiber_cnd_impl *impl = cond->_impl;
     594                 :            :         assert(impl);
     595                 :            : 
     596                 :            :         assert(sllist_empty(&impl->queue));
     597                 :            : #if !LELY_NO_THREADS
     598                 :          1 :         mtx_destroy(&impl->mtx);
     599                 :            : #endif
     600                 :          1 :         free(impl);
     601                 :            : 
     602                 :          1 :         cond->_impl = NULL;
     603                 :          1 : }
     604                 :            : 
     605                 :            : int
     606                 :          1 : ev_fiber_cnd_signal(ev_fiber_cnd_t *cond)
     607                 :            : {
     608                 :            :         assert(cond);
     609                 :          1 :         struct ev_fiber_cnd_impl *impl = cond->_impl;
     610                 :            :         assert(impl);
     611                 :            : 
     612                 :            : #if !LELY_NO_THREADS
     613                 :          1 :         mtx_lock(&impl->mtx);
     614                 :            : #endif
     615                 :          1 :         struct slnode *node = sllist_pop_front(&impl->queue);
     616                 :            : #if !LELY_NO_THREADS
     617                 :          1 :         mtx_unlock(&impl->mtx);
     618                 :            : #endif
     619                 :            : 
     620         [ +  - ]:          1 :         if (node)
     621                 :          1 :                 ev_fiber_cnd_wake(node);
     622                 :            : 
     623                 :          1 :         return ev_fiber_success;
     624                 :            : }
     625                 :            : 
     626                 :            : int
     627                 :          0 : ev_fiber_cnd_broadcast(ev_fiber_cnd_t *cond)
     628                 :            : {
     629                 :            :         assert(cond);
     630                 :          0 :         struct ev_fiber_cnd_impl *impl = cond->_impl;
     631                 :            :         assert(impl);
     632                 :            : 
     633                 :            :         struct sllist queue;
     634                 :          0 :         sllist_init(&queue);
     635                 :            : 
     636                 :            : #if !LELY_NO_THREADS
     637                 :          0 :         mtx_lock(&impl->mtx);
     638                 :            : #endif
     639                 :          0 :         sllist_append(&queue, &impl->queue);
     640                 :            : #if !LELY_NO_THREADS
     641                 :          0 :         mtx_unlock(&impl->mtx);
     642                 :            : #endif
     643                 :            : 
     644                 :            :         struct slnode *node;
     645         [ #  # ]:          0 :         while ((node = sllist_pop_front(&queue)))
     646                 :          0 :                 ev_fiber_cnd_wake(node);
     647                 :            : 
     648                 :          0 :         return ev_fiber_success;
     649                 :            : }
     650                 :            : 
     651                 :            : int
     652                 :          1 : ev_fiber_cnd_wait(ev_fiber_cnd_t *cond, ev_fiber_mtx_t *mtx)
     653                 :            : {
     654                 :          1 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     655                 :            :         assert(mtx);
     656                 :          1 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
     657                 :            :         assert(impl);
     658                 :            : 
     659         [ -  + ]:          1 :         if (!thr->curr) {
     660                 :          0 :                 set_errnum(ERRNUM_PERM);
     661                 :          0 :                 return ev_fiber_error;
     662                 :            :         }
     663                 :            : 
     664                 :          1 :         struct ev_fiber_cnd_wait wait = { .cond = cond, .mtx = mtx };
     665                 :            : 
     666                 :            : #if !LELY_NO_THREADS
     667                 :          1 :         mtx_lock(&impl->mtx);
     668                 :            : #endif
     669   [ +  -  -  + ]:          1 :         if (impl->ctx != thr->curr || impl->locked != 1) {
     670                 :            : #if !LELY_NO_THREADS
     671                 :          0 :                 mtx_unlock(&impl->mtx);
     672                 :            : #endif
     673                 :          0 :                 set_errnum(ERRNUM_PERM);
     674                 :          0 :                 return ev_fiber_error;
     675                 :            :         }
     676                 :            :         assert(impl->locked);
     677                 :            : 
     678                 :            :         // The inner mutex will be unlocked in ev_fiber_cnd_wait_func().
     679                 :          1 :         thr->prev = fiber_resume_with(thr->prev, ev_fiber_cnd_wait_func, &wait);
     680                 :            : 
     681                 :            : #if !LELY_NO_THREADS
     682                 :          1 :         mtx_lock(&impl->mtx);
     683                 :            : #endif
     684                 :            :         assert(!impl->ctx);
     685                 :          1 :         impl->ctx = thr->curr;
     686                 :            :         assert(impl->locked == 1);
     687                 :            : #if !LELY_NO_THREADS
     688                 :          1 :         mtx_unlock(&impl->mtx);
     689                 :            : #endif
     690                 :            : 
     691                 :          1 :         return ev_fiber_success;
     692                 :            : }
     693                 :            : 
     694                 :            : static void
     695                 :         84 : ev_fiber_exec_on_task_init(ev_exec_t *exec_)
     696                 :            : {
     697                 :         84 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     698                 :            : 
     699                 :         84 :         ev_exec_on_task_init(exec->inner_exec);
     700                 :         84 : }
     701                 :            : 
     702                 :            : static void
     703                 :         84 : ev_fiber_exec_on_task_fini(ev_exec_t *exec_)
     704                 :            : {
     705                 :         84 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     706                 :            : 
     707                 :         84 :         ev_exec_on_task_fini(exec->inner_exec);
     708                 :         84 : }
     709                 :            : 
     710                 :            : static int
     711                 :          0 : ev_fiber_exec_dispatch(ev_exec_t *exec_, struct ev_task *task)
     712                 :            : {
     713                 :          0 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     714                 :          0 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     715                 :            :         assert(task);
     716                 :            :         assert(!task->exec || task->exec == exec_);
     717                 :            : 
     718                 :            :         // Post the task if the executor is not currently executing a fiber.
     719                 :          0 :         struct ev_fiber_ctx *ctx = thr->curr;
     720   [ #  #  #  # ]:          0 :         if (!ctx || ctx->exec != exec) {
     721                 :          0 :                 ev_fiber_exec_post(exec_, task);
     722                 :          0 :                 return 0;
     723                 :            :         }
     724                 :            : 
     725         [ #  # ]:          0 :         if (!task->exec)
     726                 :          0 :                 task->exec = exec_;
     727                 :            : 
     728                 :            :         // Execute the task immediately.
     729         [ #  # ]:          0 :         if (task->func)
     730                 :          0 :                 task->func(task);
     731                 :            : 
     732                 :          0 :         return 1;
     733                 :            : }
     734                 :            : 
     735                 :            : static void
     736                 :         61 : ev_fiber_exec_post(ev_exec_t *exec_, struct ev_task *task)
     737                 :            : {
     738                 :         61 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     739                 :         61 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     740                 :            :         assert(task);
     741                 :            :         assert(!task->exec || task->exec == exec_);
     742                 :            : 
     743         [ -  + ]:         61 :         if (!task->exec)
     744                 :          0 :                 task->exec = exec_;
     745                 :         61 :         ev_fiber_exec_on_task_init(exec_);
     746                 :            : 
     747                 :            :         // Append the task to the queue.
     748                 :            : #if !LELY_NO_THREADS
     749                 :         61 :         mtx_lock(&exec->mtx);
     750                 :            : #endif
     751                 :         61 :         sllist_push_back(&exec->queue, &task->_node);
     752   [ +  -  -  + ]:         61 :         int post = !exec->posted && exec->thr != thr;
     753         [ -  + ]:         61 :         if (post)
     754                 :          0 :                 exec->posted = 1;
     755                 :            : #if !LELY_NO_THREADS
     756                 :         61 :         mtx_unlock(&exec->mtx);
     757                 :            : #endif
     758                 :            : 
     759                 :            :         // If no pending fibers are available (and the calling thread is the
     760                 :            :         // thread of this executor), try to post a new fiber immediately.
     761   [ +  -  +  + ]:         61 :         if (exec->thr == thr && !exec->pending)
     762                 :         44 :                 ev_fiber_exec_post_ctx(exec);
     763                 :            :         // Otherwise, post a task to post a fiber.
     764         [ -  + ]:         61 :         if (post)
     765                 :          0 :                 ev_exec_post(exec->task.exec, &exec->task);
     766                 :         61 : }
     767                 :            : 
     768                 :            : static void
     769                 :          0 : ev_fiber_exec_defer(ev_exec_t *exec_, struct ev_task *task)
     770                 :            : {
     771                 :          0 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     772                 :          0 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     773                 :            :         assert(task);
     774                 :            :         assert(!task->exec || task->exec == exec_);
     775                 :            : 
     776                 :            :         // Post the task if the executor is not currently executing a fiber.
     777                 :          0 :         struct ev_fiber_ctx *ctx = thr->curr;
     778   [ #  #  #  # ]:          0 :         if (!ctx || ctx->exec != exec) {
     779                 :          0 :                 ev_fiber_exec_post(exec_, task);
     780                 :          0 :                 return;
     781                 :            :         }
     782                 :            : 
     783         [ #  # ]:          0 :         if (!task->exec)
     784                 :          0 :                 task->exec = exec_;
     785                 :          0 :         ev_fiber_exec_on_task_init(exec_);
     786                 :            : 
     787                 :            :         // Push the task to the deferred queue of the fiber.
     788                 :          0 :         sllist_push_back(&ctx->queue, &task->_node);
     789                 :            : }
     790                 :            : 
     791                 :            : static size_t
     792                 :          3 : ev_fiber_exec_abort(ev_exec_t *exec_, struct ev_task *task)
     793                 :            : {
     794                 :          3 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     795                 :          3 :         struct ev_fiber_exec *exec = ev_fiber_exec_from_exec(exec_);
     796                 :            : 
     797                 :            :         struct sllist queue;
     798                 :          3 :         sllist_init(&queue);
     799                 :            : 
     800                 :          3 :         struct ev_fiber_ctx *ctx = thr->curr;
     801   [ -  +  -  - ]:          3 :         if (ctx && ctx->exec == exec) {
     802                 :            :                 // Try to find and abort the task(s) in the deferred queue of
     803                 :            :                 // the fiber.
     804         [ #  # ]:          0 :                 if (!task)
     805                 :          0 :                         sllist_append(&queue, &ctx->queue);
     806         [ #  # ]:          0 :                 else if (sllist_remove(&ctx->queue, &task->_node))
     807                 :          0 :                         sllist_push_back(&queue, &task->_node);
     808                 :            :         }
     809                 :            : 
     810                 :            : #if !LELY_NO_THREADS
     811                 :          3 :         mtx_lock(&exec->mtx);
     812                 :            : #endif
     813         [ +  - ]:          3 :         if (!task)
     814                 :          3 :                 sllist_append(&queue, &exec->queue);
     815         [ #  # ]:          0 :         else if (sllist_remove(&exec->queue, &task->_node))
     816                 :          0 :                 sllist_push_back(&queue, &task->_node);
     817                 :            : #if !LELY_NO_THREADS
     818                 :          3 :         mtx_unlock(&exec->mtx);
     819                 :            : #endif
     820                 :            : 
     821                 :          3 :         size_t n = 0;
     822         [ -  + ]:          3 :         while (sllist_pop_front(&queue)) {
     823                 :          0 :                 ev_fiber_exec_on_task_fini(exec_);
     824                 :          0 :                 n += n < SIZE_MAX;
     825                 :            :         }
     826                 :          3 :         return n;
     827                 :            : }
     828                 :            : 
     829                 :            : static void
     830                 :          0 : ev_fiber_exec_func(struct ev_task *task)
     831                 :            : {
     832                 :            :         assert(task);
     833                 :          0 :         struct ev_fiber_exec *exec = structof(task, struct ev_fiber_exec, task);
     834                 :            :         assert(exec->thr == &ev_fiber_thrd);
     835                 :            : 
     836                 :            : #if !LELY_NO_THREADS
     837                 :          0 :         mtx_lock(&exec->mtx);
     838                 :            : #endif
     839                 :            :         assert(exec->posted);
     840                 :          0 :         exec->posted = 0;
     841                 :            : #if !LELY_NO_THREADS
     842                 :          0 :         mtx_unlock(&exec->mtx);
     843                 :            : #endif
     844                 :            : 
     845                 :            :         // If no pending fibers are available, try to post a new fiber.
     846         [ #  # ]:          0 :         if (!exec->pending)
     847                 :          0 :                 ev_fiber_exec_post_ctx(exec);
     848                 :          0 : }
     849                 :            : 
     850                 :            : static inline struct ev_fiber_exec *
     851                 :        241 : ev_fiber_exec_from_exec(const ev_exec_t *exec)
     852                 :            : {
     853                 :            :         assert(exec);
     854                 :            : 
     855                 :        241 :         return structof(exec, struct ev_fiber_exec, exec_vptr);
     856                 :            : }
     857                 :            : 
     858                 :            : static int
     859                 :         46 : ev_fiber_exec_post_ctx(struct ev_fiber_exec *exec)
     860                 :            : {
     861                 :         46 :         int errsv = get_errc();
     862                 :         46 :         struct ev_fiber_ctx *ctx = ev_fiber_ctx_create(exec);
     863         [ -  + ]:         46 :         if (!ctx) {
     864                 :            :                 // Ignore the error; one of the existing fibers can pick up the
     865                 :            :                 // submitted task.
     866                 :          0 :                 set_errc(errsv);
     867                 :          0 :                 return -1;
     868                 :            :         }
     869                 :            : 
     870                 :         46 :         exec->pending++;
     871                 :         46 :         ev_exec_post(ctx->task.exec, &ctx->task);
     872                 :            : 
     873                 :         46 :         return 0;
     874                 :            : }
     875                 :            : 
     876                 :            : static struct ev_fiber_ctx *
     877                 :         46 : ev_fiber_ctx_create(struct ev_fiber_exec *exec)
     878                 :            : {
     879                 :         46 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     880                 :            :         assert(thr->refcnt);
     881                 :            :         assert(exec);
     882                 :            :         assert(exec->thr == thr);
     883                 :            : 
     884                 :            :         // Use a fiber from the unused list before creating a new one.
     885                 :         46 :         struct ev_fiber_ctx *ctx = thr->unused;
     886         [ +  + ]:         46 :         if (ctx) {
     887                 :         40 :                 thr->unused = ctx->next;
     888                 :         40 :                 ctx->next = NULL;
     889                 :            :                 assert(thr->num_unused);
     890                 :         40 :                 thr->num_unused--;
     891                 :            :         } else {
     892                 :          6 :                 fiber_t *fiber = fiber_create(&ev_fiber_ctx_fiber_func, NULL,
     893                 :            :                                 thr->flags, sizeof(struct ev_fiber_ctx),
     894                 :            :                                 thr->stack_size);
     895         [ -  + ]:          6 :                 if (!fiber)
     896                 :          0 :                         return NULL;
     897                 :          6 :                 ctx = fiber_data(fiber);
     898                 :          6 :                 *ctx = (struct ev_fiber_ctx){
     899                 :            :                         .fiber = fiber,
     900                 :            :                 };
     901                 :          6 :                 sllist_init(&ctx->queue);
     902                 :            :         }
     903                 :            : 
     904                 :            :         // Associate the fiber with the executor.
     905                 :         46 :         ctx->exec = exec;
     906                 :         46 :         ctx->task = (struct ev_task)EV_TASK_INIT(
     907                 :            :                         exec->inner_exec, &ev_fiber_ctx_task_func);
     908                 :            : 
     909                 :         46 :         return ctx;
     910                 :            : }
     911                 :            : 
     912                 :            : static void
     913                 :         46 : ev_fiber_ctx_destroy(struct ev_fiber_ctx *ctx)
     914                 :            : {
     915                 :         46 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     916                 :            :         assert(thr->refcnt);
     917                 :            : 
     918         [ +  - ]:         46 :         if (ctx) {
     919                 :            :                 assert(sllist_empty(&ctx->queue));
     920         [ +  - ]:         46 :                 if (thr->num_unused < thr->max_unused) {
     921                 :         46 :                         ctx->next = thr->unused;
     922                 :         46 :                         thr->unused = ctx;
     923                 :         46 :                         thr->num_unused++;
     924                 :            :                 } else {
     925                 :          0 :                         fiber_destroy(ctx->fiber);
     926                 :            :                 }
     927                 :            :         }
     928                 :         46 : }
     929                 :            : 
     930                 :            : static fiber_t *
     931                 :          6 : ev_fiber_ctx_fiber_func(fiber_t *fiber, void *arg)
     932                 :            : {
     933                 :          6 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     934                 :            :         (void)arg;
     935                 :          6 :         struct ev_fiber_ctx *ctx = fiber_data(NULL);
     936                 :            : 
     937                 :          6 :         thr->prev = fiber;
     938                 :            : 
     939                 :          6 :         struct ev_task *task = NULL;
     940                 :        101 :         for (;;) {
     941         [ +  - ]:        107 :                 if (!task) {
     942                 :            :                         // Check if there are any tasks waiting on the queue of
     943                 :            :                         // the executor.
     944                 :            :                         assert(ctx->exec->pending);
     945                 :        107 :                         ctx->exec->pending--;
     946                 :            : #if !LELY_NO_THREADS
     947                 :        107 :                         mtx_lock(&ctx->exec->mtx);
     948                 :            : #endif
     949                 :        107 :                         task = ev_task_from_node(
     950                 :        107 :                                         sllist_pop_front(&ctx->exec->queue));
     951                 :            : #if !LELY_NO_THREADS
     952                 :        107 :                         mtx_unlock(&ctx->exec->mtx);
     953                 :            : #endif
     954                 :            :                         // If no tasks are available, return and destroy the
     955                 :            :                         // fiber or put it on the unused list.
     956         [ +  + ]:        107 :                         if (!task) {
     957                 :         46 :                                 ev_fiber_return();
     958                 :         40 :                                 continue;
     959                 :            :                         }
     960                 :            :                 }
     961                 :            : 
     962                 :            :                 // Execute the task.
     963                 :         61 :                 ev_exec_t *exec = task->exec;
     964                 :            :                 assert(exec == &ctx->exec->exec_vptr);
     965         [ +  - ]:         61 :                 if (task->func)
     966                 :         61 :                         task->func(task);
     967                 :         61 :                 ev_fiber_exec_on_task_fini(exec);
     968                 :            : 
     969                 :            :                 // Check if there are any deferred tasks remaining.
     970                 :         61 :                 task = ev_task_from_node(sllist_pop_front(&ctx->queue));
     971         [ +  - ]:         61 :                 if (!task)
     972                 :         61 :                         ctx->exec->pending++;
     973                 :            : 
     974                 :         61 :                 ev_fiber_await(NULL);
     975                 :            :         }
     976                 :            : 
     977                 :            :         return NULL;
     978                 :            : }
     979                 :            : 
     980                 :            : static void
     981                 :   16777358 : ev_fiber_ctx_task_func(struct ev_task *task)
     982                 :            : {
     983                 :   16777358 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     984                 :            :         assert(task);
     985                 :   16777358 :         struct ev_fiber_ctx *ctx = structof(task, struct ev_fiber_ctx, task);
     986                 :            : 
     987                 :   16777358 :         thr->curr = ctx;
     988                 :   16777358 :         fiber_t *fiber = fiber_resume(ctx->fiber);
     989                 :            :         assert(!fiber);
     990                 :            :         (void)fiber;
     991                 :   16777358 : }
     992                 :            : 
     993                 :            : static struct ev_fiber_ctx *
     994                 :   16777312 : ev_fiber_resume(fiber_t *fiber)
     995                 :            : {
     996                 :   16777312 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
     997                 :            : 
     998                 :   16777312 :         struct ev_fiber_ctx *ctx = thr->curr;
     999                 :   16777312 :         thr->curr = NULL;
    1000                 :   16777312 :         ctx->fiber = fiber;
    1001                 :            : 
    1002                 :            :         // If there are tasks on the queue, but no pending fibers to execute
    1003                 :            :         // them, try to post a new fiber.
    1004                 :   16777312 :         struct ev_fiber_exec *exec = ctx->exec;
    1005         [ +  + ]:   16777312 :         if (!exec->pending) {
    1006                 :            : #if !LELY_NO_THREADS
    1007                 :   16777229 :                 mtx_lock(&exec->mtx);
    1008                 :            : #endif
    1009                 :   16777229 :                 int empty = sllist_empty(&exec->queue);
    1010                 :            : #if !LELY_NO_THREADS
    1011                 :   16777229 :                 mtx_unlock(&exec->mtx);
    1012                 :            : #endif
    1013         [ +  + ]:   16777229 :                 if (!empty)
    1014                 :          2 :                         ev_fiber_exec_post_ctx(exec);
    1015                 :            :         }
    1016                 :            : 
    1017                 :   16777312 :         return ctx;
    1018                 :            : }
    1019                 :            : 
    1020                 :            : static fiber_t *
    1021                 :   16777310 : ev_fiber_await_func(fiber_t *fiber, void *arg)
    1022                 :            : {
    1023                 :   16777310 :         ev_future_t *future = arg;
    1024                 :            : 
    1025                 :   16777310 :         struct ev_fiber_ctx *ctx = ev_fiber_resume(fiber);
    1026                 :            : 
    1027         [ +  + ]:   16777310 :         if (future)
    1028                 :         28 :                 ev_future_submit(future, &ctx->task);
    1029                 :            :         else
    1030                 :   16777282 :                 ev_exec_post(ctx->task.exec, &ctx->task);
    1031                 :            : 
    1032                 :   16777310 :         return NULL;
    1033                 :            : }
    1034                 :            : 
    1035                 :            : static void
    1036                 :         46 : ev_fiber_return(void)
    1037                 :            : {
    1038                 :         46 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
    1039                 :            :         assert(thr->curr);
    1040                 :            : 
    1041                 :         46 :         thr->prev = fiber_resume_with(thr->prev, ev_fiber_return_func, NULL);
    1042                 :         40 : }
    1043                 :            : 
    1044                 :            : static fiber_t *
    1045                 :         46 : ev_fiber_return_func(fiber_t *fiber, void *arg)
    1046                 :            : {
    1047                 :         46 :         struct ev_fiber_thrd *thr = &ev_fiber_thrd;
    1048                 :            :         (void)arg;
    1049                 :            : 
    1050                 :         46 :         struct ev_fiber_ctx *ctx = thr->curr;
    1051                 :         46 :         thr->curr = NULL;
    1052                 :         46 :         ctx->fiber = fiber;
    1053                 :            : 
    1054                 :            :         // Destroy the fiber or put it back on the unused list.
    1055                 :         46 :         ev_fiber_ctx_destroy(ctx);
    1056                 :            : 
    1057                 :         46 :         return NULL;
    1058                 :            : }
    1059                 :            : 
    1060                 :            : static fiber_t *
    1061                 :          1 : ev_fiber_mtx_lock_func(fiber_t *fiber, void *arg)
    1062                 :            : {
    1063                 :          1 :         struct ev_fiber_mtx_impl *impl = arg;
    1064                 :            :         assert(impl);
    1065                 :            : 
    1066                 :          1 :         struct ev_fiber_ctx *ctx = ev_fiber_resume(fiber);
    1067                 :            : 
    1068                 :            :         // Append the fiber to the queue of waiting fibers.
    1069                 :          1 :         sllist_push_back(&impl->queue, &ctx->task._node);
    1070                 :            : #if !LELY_NO_THREADS
    1071                 :            :         // Unlock the inner mutex locked in ev_fiber_mtx_lock().
    1072                 :          1 :         mtx_unlock(&impl->mtx);
    1073                 :            : #endif
    1074                 :            : 
    1075                 :          1 :         return NULL;
    1076                 :            : }
    1077                 :            : 
    1078                 :            : static fiber_t *
    1079                 :          1 : ev_fiber_cnd_wait_func(fiber_t *fiber, void *arg)
    1080                 :            : {
    1081                 :          1 :         struct ev_fiber_cnd_wait *wait = arg;
    1082                 :            :         assert(wait);
    1083                 :          1 :         ev_fiber_cnd_t *cond = wait->cond;
    1084                 :            :         assert(cond);
    1085                 :          1 :         struct ev_fiber_cnd_impl *cond_impl = cond->_impl;
    1086                 :            :         assert(cond_impl);
    1087                 :          1 :         ev_fiber_mtx_t *mtx = wait->mtx;
    1088                 :          1 :         struct ev_fiber_mtx_impl *mtx_impl = mtx->_impl;
    1089                 :            :         assert(mtx_impl);
    1090                 :            : 
    1091                 :          1 :         struct ev_fiber_ctx *ctx = ev_fiber_resume(fiber);
    1092                 :            : 
    1093                 :          1 :         wait->task = &ctx->task;
    1094                 :            : #if !LELY_NO_THREADS
    1095                 :          1 :         mtx_lock(&cond_impl->mtx);
    1096                 :            : #endif
    1097                 :          1 :         sllist_push_back(&cond_impl->queue, &wait->node);
    1098                 :            : #if !LELY_NO_THREADS
    1099                 :          1 :         mtx_unlock(&cond_impl->mtx);
    1100                 :            : #endif
    1101                 :            : 
    1102                 :            :         // Unlock the mutex for the duration of the wait.
    1103                 :          1 :         mtx_impl->ctx = NULL;
    1104                 :            :         assert(mtx_impl->locked == 1);
    1105                 :          1 :         mtx_impl->locked = 0;
    1106                 :            :         struct ev_task *task =
    1107                 :          1 :                         ev_task_from_node(sllist_pop_front(&mtx_impl->queue));
    1108         [ -  + ]:          1 :         if (task)
    1109                 :          0 :                 mtx_impl->locked++;
    1110                 :            : #if !LELY_NO_THREADS
    1111                 :          1 :         mtx_unlock(&mtx_impl->mtx);
    1112                 :            : #endif
    1113                 :            :         // cppcheck-suppress duplicateCondition
    1114         [ -  + ]:          1 :         if (task)
    1115                 :          0 :                 ev_exec_post(task->exec, task);
    1116                 :            : 
    1117                 :          1 :         return NULL;
    1118                 :            : }
    1119                 :            : 
    1120                 :            : static void
    1121                 :          1 : ev_fiber_cnd_wake(struct slnode *node)
    1122                 :            : {
    1123                 :            :         assert(node);
    1124                 :          1 :         struct ev_fiber_cnd_wait *wait =
    1125                 :          1 :                         structof(node, struct ev_fiber_cnd_wait, node);
    1126                 :          1 :         ev_fiber_mtx_t *mtx = wait->mtx;
    1127                 :            :         assert(mtx);
    1128                 :          1 :         struct ev_fiber_mtx_impl *impl = mtx->_impl;
    1129                 :            :         assert(impl);
    1130                 :          1 :         struct ev_task *task = wait->task;
    1131                 :            :         assert(task);
    1132                 :            : 
    1133                 :            : #if !LELY_NO_THREADS
    1134                 :          1 :         mtx_lock(&impl->mtx);
    1135                 :            : #endif
    1136         [ +  - ]:          1 :         if (impl->locked) {
    1137                 :          1 :                 sllist_push_back(&impl->queue, &task->_node);
    1138                 :          1 :                 task = NULL;
    1139                 :            :         } else {
    1140                 :            :                 assert(sllist_empty(&impl->queue));
    1141                 :          0 :                 impl->locked = 1;
    1142                 :            :         }
    1143                 :            : #if !LELY_NO_THREADS
    1144                 :          1 :         mtx_unlock(&impl->mtx);
    1145                 :            : #endif
    1146                 :            : 
    1147         [ -  + ]:          1 :         if (task)
    1148                 :          0 :                 ev_exec_post(task->exec, task);
    1149                 :          1 : }
    1150                 :            : 
    1151                 :            : #endif // !LELY_NO_MALLOC

Generated by: LCOV version 1.14